const std = @import("std");
const api = @import("api.zig");
const memory = @import("memory.zig");
const caps = @import("caps.zig");

// 暂时注释掉尚未创建的依赖
// const cpu = @import("cpu.zig");
// const trap = @import("trap.zig");
// const gpu = @import("gpu.zig");
// const display = @import("display.zig");
// const ui_comm = @import("ui_comm.zig");
// const driver_manager = @import("driver_manager.zig");
// const kotlin_native_ffi = @import("kotlin_native_ffi.zig");

// KuyaKernel 主结构体
pub const KuyaKernel = struct {
    memory_manager: memory.MemoryManager,
    // 暂时注释掉尚未创建的组件
    // cpu_manager: cpu.CpuManager,
    // trap_handler: trap.TrapHandler,
    capability_manager: caps.CapabilityManager,
    // driver_manager: driver_manager.DriverManager,
    // gpu_manager: gpu.GpuManager,
    // display_manager: display.DisplayManager,
    // ui_comm_manager: ui_comm.UICommManager,

    // 初始化 KuyaKernel
    pub fn init(allocator: std.mem.Allocator) !KuyaKernel {
        // 先初始化基础管理器
        var memory_manager = try memory.MemoryManager.init(allocator);
        // var cpu_manager = cpu.CpuManager.init();
        // var trap_handler = try trap.TrapHandler.init();
        var capability_manager = caps.CapabilityManager.init(allocator);
        
        // 暂时跳过驱动管理器初始化，因为依赖尚未创建
        // var driver_manager_instance = try driver_manager.DriverManager.init(
        //     allocator,
        //     &memory_manager,
        //     &capability_manager,
        //     &trap_handler
        // );
        
        var kernel = KuyaKernel{
            .memory_manager = memory_manager,
            // .cpu_manager = cpu_manager,
            // .trap_handler = trap_handler,
            .capability_manager = capability_manager,
            // .driver_manager = driver_manager_instance,
            // .gpu_manager = try gpu.GpuManager.init(allocator),
            // .display_manager = try display.DisplayManager.init(allocator),
            // .ui_comm_manager = try ui_comm.UICommManager.init(allocator),
        };

        // 初始化硬件抽象
        try kernel.initHardware();

        return kernel;
    }

    // 初始化硬件
    fn initHardware(self: *KuyaKernel) !void {
        // 设置内存映射
        try self.memory_manager.setupMemoryMap();

        // 暂时注释掉尚未创建的初始化代码
        // // 初始化CPU控制结构
        // self.cpu_manager.initControlRegisters();

        // // 设置中断处理
        // try self.trap_handler.setupInterrupts();

        // 初始化能力系统
        try self.capability_manager.initRootCapabilities();
        
        // 暂时注释掉尚未创建的组件初始化
        // // 初始化全局GPU和显示管理器实例
        // gpu.global_gpu_manager = self.gpu_manager;
        // display.global_display_manager = self.display_manager;
        
        // // 初始化UI通信管理器
        // ui_comm.global_ui_comm_manager = self.ui_comm_manager;
        // self.ui_comm_manager.initialize();
        
        // // 初始化Kotlin/Native FFI
        // try kotlin_native_ffi.init_ffi(allocator);
    }

    // 启动KuyaKernel
    pub fn start(self: *KuyaKernel) !void {
        std.log.info("KuyaKernel started. Welcome to Kuya!");

        // 进入服务层启动阶段
        try self.prepareServiceLayer();
    }

    // 为服务层准备环境
    fn prepareServiceLayer(self: *KuyaKernel) !void {
        // 创建初始能力
        const mem_cap = try self.capability_manager.createCapability(
            .{ .type = .memory, .size = 0x1000000 }, // 16MB 初始内存
        );
        // 暂时跳过CPU能力创建，因为依赖尚未创建
        // const cpu_cap = try self.capability_manager.createCapability(
        //     .{ .type = .cpu, .priority = 10 },
        // );
        
        // 暂时跳过IO能力创建，因为依赖尚未创建
        // const io_cap = try self.capability_manager.createCapability(
        //     .{ .type = .io, .port_range = .{ .start = 0, .end = 0xFFFF } },
        // );

        // 暂时跳过设置服务层能力的代码
        // 记录能力ID以便服务层获取
        // self.capability_manager.setServiceLayerCapabilities(mem_cap, cpu_cap);
        
        // 暂时跳过显示设置的代码
        // 设置初始显示模式（使用第一个显示设备的第一个模式）
        // if (self.display_manager.devices.items.len > 0) {
        //     const device_id = self.display_manager.devices.items[0].id;
        //     if (self.display_manager.devices.items[0].modes.items.len > 0) {
        //         _ = self.display_manager.setDisplayMode(device_id, 0);
        //     }
        // }
    }

    // 清理资源
    pub fn deinit(self: *KuyaKernel, allocator: std.mem.Allocator) void {
        // 暂时跳过驱动管理器清理，因为依赖尚未创建
        // // 先清理驱动管理器
        // self.driver_manager.deinit();
        
        // 然后清理其他管理器
        self.memory_manager.deinit(allocator);
        // self.trap_handler.deinit();
        self.capability_manager.deinit(allocator);
        // self.gpu_manager.deinit();
        // self.display_manager.deinit();
        // UI通信管理器资源在服务层关闭时释放
        // 清理Kotlin/Native FFI资源
        // kotlin_native_ffi.deinit_ffi();
    }
};

// 主入口点（用于独立测试）
pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    defer _ = gpa.deinit();

    var kernel = try KuyaKernel.init(allocator);
    defer kernel.deinit(allocator);

    try kernel.start();

    // 进入待机状态（实际系统中会进入服务层）
    std.log.info("KuyaKernel entering idle state...");
    while (true) {
        // 暂时跳过CPU空闲指令，因为依赖尚未创建
        // cpu.idle();
        std.time.sleep(1000000000); // 睡眠1秒
    }
}